/*
 * Copyright (C) 2005-2011 MaNGOS <http://www.getmangos.com/>
 *
 * Copyright (C) 2008-2011 Trinity <http://www.trinitycore.org/>
 *
 * Copyright (C) 2010-2011 ArkCORE <http://www.arkania.net/>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#ifndef _SPELLMGR_H
#define _SPELLMGR_H

// For static or at-server-startup loaded spell data
// For more high level function for sSpellStore data

#include "SharedDefines.h"
#include "SpellAuraDefines.h"
#include "DBCStructure.h"
#include "DBCStores.h"
#include "SQLStorage.h"

#include "UnorderedMap.h"

#include "Player.h"

#include <map>
#include <cmath>

class Player;
class Spell;
struct SpellModifier;

// only used in code
enum SpellCategories {
	SPELLCATEGORY_HEALTH_MANA_POTIONS = 4,
	SPELLCATEGORY_DEVOUR_MAGIC = 12,
	SPELLCATEGORY_JUDGEMENT = 1210, // Judgement (seal trigger)
	SPELLCATEGORY_FOOD = 11,
	SPELLCATEGORY_DRINK = 59,
};

enum SpellEffectTargetTypes {
	SPELL_REQUIRE_NONE,
	SPELL_REQUIRE_UNIT,
	SPELL_REQUIRE_DEST,
	SPELL_REQUIRE_ITEM,
	SPELL_REQUIRE_CASTER,
	SPELL_REQUIRE_GOBJECT,
};

enum SpellSelectTargetTypes {
	TARGET_TYPE_DEFAULT,
	TARGET_TYPE_UNIT_CASTER,
	TARGET_TYPE_UNIT_TARGET,
	TARGET_TYPE_UNIT_NEARBY,
	TARGET_TYPE_AREA_SRC,
	TARGET_TYPE_AREA_DST,
	TARGET_TYPE_AREA_CONE,
	TARGET_TYPE_DEST_CASTER,
	TARGET_TYPE_DEST_TARGET,
	TARGET_TYPE_DEST_DEST,
	TARGET_TYPE_DEST_SPECIAL,
	TARGET_TYPE_CHANNEL,
};

//SpellFamilyFlags
enum SpellFamilyFlag {
	// SPELLFAMILYFLAG  = SpellFamilyFlags[0]
	// SPELLFAMILYFLAG1 = SpellFamilyFlags[1]
	// SPELLFAMILYFLAG2 = SpellFamilyFlags[2]

	// Rogue
	SPELLFAMILYFLAG_ROGUE_VANISH = 0x00000800,
	SPELLFAMILYFLAG_ROGUE_STEALTH = 0x00400000,
	SPELLFAMILYFLAG_ROGUE_BACKSTAB = 0x00800004,
	SPELLFAMILYFLAG_ROGUE_SAP = 0x00000080,
	SPELLFAMILYFLAG_ROGUE_FEINT = 0x08000000,
	SPELLFAMILYFLAG_ROGUE_KIDNEYSHOT = 0x00200000,
	SPELLFAMILYFLAG1_ROGUE_HUNGERFORBLOOD = 0x01000000,
	SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT = 0x00000860, // Vanish, Evasion, Sprint
	SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP = 0x00000240, // Cold Blood, Shadowstep
	SPELLFAMILYFLAG_ROGUE_KICK = 0x00000010, // Kick
	SPELLFAMILYFLAG1_ROGUE_DISMANTLE = 0x00100000, // Dismantle
	SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY = 0x40000000, // Blade Flurry
	SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY = 0x00000800, // Blade Flurry
	//SPELLFAMILYFLAG_ROGUE__FINISHING_MOVE  = 0x9003E0000LL,

	// Warrior
	SPELLFAMILYFLAG_WARRIOR_SUNDERARMOR = 0x00004000,
	SPELLFAMILYFLAG_WARRIOR_CHARGE = 0x00000001,
	SPELLFAMILYFLAG_WARRIOR_SLAM = 0x00200000,
	SPELLFAMILYFLAG_WARRIOR_EXECUTE = 0x20000000,
	SPELLFAMILYFLAG_WARRIOR_CONCUSSION_BLOW = 0x04000000,

	// Mage
	SPELLFAMILYFLAG1_MAGE_CONEOFCOLD = 0x00000200,

	// Warlock
	SPELLFAMILYFLAG_WARLOCK_LIFETAP = 0x00040000,

	// Priest
	SPELLFAMILYFLAG1_PRIEST_PENANCE = 0x00800000,

	// Druid
	SPELLFAMILYFLAG2_DRUID_STARFALL = 0x00000100,

	// Paladin
	SPELLFAMILYFLAG1_PALADIN_DIVINESTORM = 0x00020000,

	// Shaman
	SPELLFAMILYFLAG_SHAMAN_FROST_SHOCK = 0x80000000,
	SPELLFAMILYFLAG_SHAMAN_HEALING_STREAM = 0x00002000,
	SPELLFAMILYFLAG_SHAMAN_MANA_SPRING = 0x00004000,
	SPELLFAMILYFLAG2_SHAMAN_LAVA_LASH = 0x00000004,
	SPELLFAMILYFLAG_SHAMAN_FLAMETONGUE = 0x00200000,
	SPELLFAMILYFLAG_SHAMAN_FIRE_NOVA = 0x28000000,

	// Deathknight
	SPELLFAMILYFLAG_DK_DEATH_STRIKE = 0x00000010,
	SPELLFAMILYFLAG1_DK_SCOURGE_STRIKE = 0x08000000,
	SPELLFAMILYFLAG_DK_DEATH_COIL = 0x00002000,
	SPELLFAMILYFLAG1_DK_HUNGERING_COLD = 0x00001000,
	SPELLFAMILYFLAG_DK_CHAINS_OF_ICE = 0x00000004,

	// TODO: Figure out a more accurate name for the following familyflag(s)
	SPELLFAMILYFLAG_SHAMAN_TOTEM_EFFECTS = 0x04000000,
// Seems to be linked to most totems and some totem effects
};

// Spell clasification
enum SpellSpecific {
	SPELL_SPECIFIC_NORMAL = 0,
	SPELL_SPECIFIC_SEAL = 1,
	SPELL_SPECIFIC_AURA = 3,
	SPELL_SPECIFIC_STING = 4,
	SPELL_SPECIFIC_CURSE = 5,
	SPELL_SPECIFIC_ASPECT = 6,
	SPELL_SPECIFIC_TRACKER = 7,
	SPELL_SPECIFIC_WARLOCK_ARMOR = 8,
	SPELL_SPECIFIC_MAGE_ARMOR = 9,
	SPELL_SPECIFIC_ELEMENTAL_SHIELD = 10,
	SPELL_SPECIFIC_MAGE_POLYMORPH = 11,
	SPELL_SPECIFIC_JUDGEMENT = 13,
	SPELL_SPECIFIC_WARLOCK_CORRUPTION = 17,
	SPELL_SPECIFIC_FOOD = 19,
	SPELL_SPECIFIC_DRINK = 20,
	SPELL_SPECIFIC_FOOD_AND_DRINK = 21,
	SPELL_SPECIFIC_PRESENCE = 22,
	SPELL_SPECIFIC_CHARM = 23,
	SPELL_SPECIFIC_SCROLL = 24,
	SPELL_SPECIFIC_MAGE_ARCANE_BRILLANCE = 25,
	SPELL_SPECIFIC_WARRIOR_ENRAGE = 26,
	SPELL_SPECIFIC_PRIEST_DIVINE_SPIRIT = 27,
	SPELL_SPECIFIC_HAND = 28,
	SPELL_SPECIFIC_PHASE = 29,
};

#define SPELL_LINKED_MAX_SPELLS  200000

enum SpellLinkedType {
	SPELL_LINK_CAST = 0, // +: cast; -: remove
	SPELL_LINK_HIT = 1 * 200000,
	SPELL_LINK_AURA = 2 * 200000, // +: aura; -: immune
	SPELL_LINK_REMOVE = 0,
};

Unit * GetTriggeredSpellCaster(SpellEntry const * spellInfo, Unit * caster,
		Unit * target);
SpellSpecific GetSpellSpecific(SpellEntry const * spellInfo);
AuraState GetSpellAuraState(SpellEntry const * spellInfo);

// Different spell properties
inline float GetSpellRadiusForHostile(SpellRadiusEntry const *radius) {
	return (radius ? radius->radiusHostile : 0);
}
inline float GetSpellRadiusForFriend(SpellRadiusEntry const *radius) {
	return (radius ? radius->radiusFriend : 0);
}
uint32 GetSpellCastTime(SpellEntry const* spellInfo, Spell * spell = NULL);
uint32 GetDispelChance(Unit* auraCaster, Unit* target, uint32 spellId,
		bool offensive, bool *result);
inline float GetSpellMinRangeForHostile(SpellRangeEntry const *range) {
	return (range ? range->minRangeHostile : 0);
}
inline float GetSpellMaxRangeForHostile(SpellRangeEntry const *range) {
	return (range ? range->maxRangeHostile : 0);
}
inline float GetSpellMinRangeForFriend(SpellRangeEntry const *range) {
	return (range ? range->minRangeFriend : 0);
}
inline float GetSpellMaxRangeForFriend(SpellRangeEntry const *range) {
	return (range ? range->maxRangeFriend : 0);
}
inline uint32 GetSpellRangeType(SpellRangeEntry const *range) {
	return (range ? range->type : 0);
}
inline uint32 GetSpellRecoveryTime(SpellEntry const *spellInfo) {
	return spellInfo->RecoveryTime > spellInfo->CategoryRecoveryTime ?
			spellInfo->RecoveryTime : spellInfo->CategoryRecoveryTime;
}
int32 GetSpellDuration(SpellEntry const *spellInfo);
int32 GetSpellMaxDuration(SpellEntry const *spellInfo);
inline float GetSpellRadius(SpellEntry const *spellInfo, uint32 effectIdx,
		bool positive) {
	return positive ?
			GetSpellRadiusForFriend(
					sSpellRadiusStore.LookupEntry(
							spellInfo->EffectRadiusIndex[effectIdx])) :
			GetSpellRadiusForHostile(
					sSpellRadiusStore.LookupEntry(
							spellInfo->EffectRadiusIndex[effectIdx]));
}

inline float GetSpellMaxRange(SpellEntry const *spellInfo, bool positive) {
	return positive ?
			GetSpellMaxRangeForFriend(
					sSpellRangeStore.LookupEntry(spellInfo->rangeIndex)) :
			GetSpellMaxRangeForHostile(
					sSpellRangeStore.LookupEntry(spellInfo->rangeIndex));
}

inline float GetSpellMinRange(SpellEntry const *spellInfo, bool positive) {
	return positive ?
			GetSpellMinRangeForFriend(
					sSpellRangeStore.LookupEntry(spellInfo->rangeIndex)) :
			GetSpellMinRangeForHostile(
					sSpellRangeStore.LookupEntry(spellInfo->rangeIndex));
}

inline float GetSpellMinRange(uint32 id, bool positive) {
	SpellEntry const *spellInfo = GetSpellStore()->LookupEntry(id);
	if (!spellInfo)
		return 0;
	return GetSpellMinRange(spellInfo, positive);
}

inline float GetSpellMaxRange(uint32 id, bool positive) {
	SpellEntry const *spellInfo = GetSpellStore()->LookupEntry(id);
	if (!spellInfo)
		return 0;
	return GetSpellMaxRange(spellInfo, positive);
}

/*struct DispelEntry
 {
 uint64 casterGuid;
 uint32 spellId;
 Unit * caster;
 uint8 stackAmount;

 bool operator < (const DispelEntry & _Right) const
 {
 return (spellId != _Right.spellId ? spellId < _Right.spellId : casterGuid < _Right.casterGuid);
 }
 };*/

inline bool IsSpellHaveEffect(SpellEntry const *spellInfo,
		SpellEffects effect) {
	for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
		if (SpellEffects(spellInfo->Effect[i]) == effect)
			return true;
	return false;
}

inline bool IsSpellHaveAura(SpellEntry const *spellInfo, AuraType aura) {
	for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
		if (AuraType(spellInfo->EffectApplyAuraName[i]) == aura)
			return true;
	return false;
}

//bool IsNoStackAuraDueToAura(uint32 spellId_1, uint32 effIndex_1, uint32 spellId_2, uint32 effIndex_2);

inline bool IsSealSpell(SpellEntry const *spellInfo) {
	//Collection of all the seal family flags. No other paladin spell has any of those.
	return spellInfo->SpellFamilyName == SPELLFAMILY_PALADIN
			&& (spellInfo->SpellFamilyFlags[1] & 0x80000000 // Seal of Justice
			|| spellInfo->SpellFamilyFlags[1] & 0x20000000 // Seal of Righteoussness
			|| spellInfo->SpellFamilyFlags[1] & 0x00000800 // Seal of Truth
			|| spellInfo->SpellFamilyFlags[1] & 0x02000000); // Seal of Insigth
}

inline bool IsElementalShield(SpellEntry const *spellInfo) {
	// family flags 10 (Lightning), 42 (Earth), 37 (Water), proc shield from T2 8 pieces bonus
	return (spellInfo->SpellFamilyFlags[1] & 0x420
			|| spellInfo->SpellFamilyFlags[0] & 0x00000400)
			|| spellInfo->Id == 23552;
}

inline bool IsExplicitDiscoverySpell(SpellEntry const *spellInfo) {
	return (((spellInfo->Effect[0] == SPELL_EFFECT_CREATE_RANDOM_ITEM
			|| spellInfo->Effect[0] == SPELL_EFFECT_CREATE_ITEM_2)
			&& spellInfo->Effect[1] == SPELL_EFFECT_SCRIPT_EFFECT)
			|| spellInfo->Id == 64323); // Book of Glyph Mastery (Effect0 == SPELL_EFFECT_SCRIPT_EFFECT without any other data)
}

inline bool IsLootCraftingSpell(SpellEntry const *spellInfo) {
	return (spellInfo->Effect[0] == SPELL_EFFECT_CREATE_RANDOM_ITEM ||
	// different random cards from Inscription (121==Virtuoso Inking Set category) r without explicit item
			(spellInfo->Effect[0] == SPELL_EFFECT_CREATE_ITEM_2
					&& (spellInfo->TotemCategory[0] != 0
							|| spellInfo->EffectItemType[0] == 0)));
}

bool IsHigherHankOfSpell(uint32 spellId_1, uint32 spellId_2);
bool IsSingleFromSpellSpecificPerCaster(SpellSpecific spellSpec1,
		SpellSpecific spellSpec2);
bool IsSingleFromSpellSpecificPerTarget(SpellSpecific spellSpec1,
		SpellSpecific spellSpec2);
bool IsPassiveSpell(uint32 spellId);
bool IsPassiveSpell(SpellEntry const * spellInfo);
bool IsAutocastableSpell(uint32 spellId);

uint32 CalculatePowerCost(SpellEntry const * spellInfo, Unit const * caster,
		SpellSchoolMask schoolMask);

inline bool IsPassiveSpellStackableWithRanks(SpellEntry const* spellProto) {
	if (!IsPassiveSpell(spellProto->Id))
		return false;

	return !IsSpellHaveEffect(spellProto, SPELL_EFFECT_APPLY_AURA);
}

inline bool IsDeathPersistentSpell(SpellEntry const *spellInfo) {
	return spellInfo->AttributesEx3 & SPELL_ATTR3_DEATH_PERSISTENT;
}

inline bool IsRequiringDeadTargetSpell(SpellEntry const *spellInfo) {
	return spellInfo->AttributesEx3 & SPELL_ATTR3_REQUIRE_DEAD_TARGET;
}

inline bool IsAllowingDeadTargetSpell(SpellEntry const *spellInfo) {
	return spellInfo->AttributesEx2 & SPELL_ATTR2_ALLOW_DEAD_TARGET;
}

inline bool IsDeadTargetSpell(SpellEntry const *spellInfo) {
	return IsAllowingDeadTargetSpell(spellInfo)
			|| IsRequiringDeadTargetSpell(spellInfo);
}

inline bool IsNonCombatSpell(SpellEntry const *spellInfo) {
	return (spellInfo->Attributes & SPELL_ATTR0_CANT_USED_IN_COMBAT) != 0;
}

bool IsPositiveSpell(uint32 spellId);
bool IsPositiveEffect(uint32 spellId, uint32 effIndex);
bool IsPositiveTarget(uint32 targetA, uint32 targetB);
bool CanSpellDispelAura(SpellEntry const * dispelSpell,
		SpellEntry const * aura);
bool CanSpellPierceImmuneAura(SpellEntry const * pierceSpell,
		SpellEntry const * aura);

bool IsSingleTargetSpell(SpellEntry const *spellInfo);
bool IsSingleTargetSpells(SpellEntry const *spellInfo1,
		SpellEntry const *spellInfo2);

extern bool IsAreaEffectTarget[TOTAL_SPELL_TARGETS];
extern SpellEffectTargetTypes EffectTargetType[TOTAL_SPELL_EFFECTS];
extern SpellSelectTargetTypes SpellTargetType[TOTAL_SPELL_TARGETS];

inline bool IsCasterSourceTarget(uint32 target) {
	switch (SpellTargetType[target]) {
	case TARGET_TYPE_UNIT_CASTER:
	case TARGET_TYPE_AREA_SRC:
	case TARGET_TYPE_AREA_CONE:
	case TARGET_TYPE_DEST_CASTER:
		return true;
	default:
		break;
	}
	return false;
}

inline bool IsPositionTarget(uint32 target) {
	switch (SpellTargetType[target]) {
	case TARGET_TYPE_DEST_CASTER:
	case TARGET_TYPE_DEST_TARGET:
	case TARGET_TYPE_DEST_DEST:
		return true;
	default:
		break;
	}
	return false;
}

inline bool IsSpellWithCasterSourceTargetsOnly(SpellEntry const* spellInfo) {
	for (int i = 0; i < MAX_SPELL_EFFECTS; ++i) {
		uint32 targetA = spellInfo->EffectImplicitTargetA[i];
		if (targetA && !IsCasterSourceTarget(targetA))
			return false;

		uint32 targetB = spellInfo->EffectImplicitTargetB[i];
		if (targetB && !IsCasterSourceTarget(targetB))
			return false;

		if (!targetA && !targetB)
			return false;
	}
	return true;
}

inline bool IsAreaOfEffectSpell(SpellEntry const *spellInfo) {
	if (IsAreaEffectTarget[spellInfo->EffectImplicitTargetA[0]]
			|| IsAreaEffectTarget[spellInfo->EffectImplicitTargetB[0]])
		return true;
	if (IsAreaEffectTarget[spellInfo->EffectImplicitTargetA[1]]
			|| IsAreaEffectTarget[spellInfo->EffectImplicitTargetB[1]])
		return true;
	if (IsAreaEffectTarget[spellInfo->EffectImplicitTargetA[2]]
			|| IsAreaEffectTarget[spellInfo->EffectImplicitTargetB[2]])
		return true;
	return false;
}

inline bool IsAreaOfEffectSpellEffect(SpellEntry const *spellInfo,
		uint8 effIndex) {
	if (IsAreaEffectTarget[spellInfo->EffectImplicitTargetA[effIndex]]
			|| IsAreaEffectTarget[spellInfo->EffectImplicitTargetB[effIndex]])
		return true;
	return false;
}

inline bool IsFarUnitTargetEffect(uint32 effect) {
	return (effect == SPELL_EFFECT_SUMMON_PLAYER);
}

inline bool IsFarDestTargetEffect(uint32 effect) {
	return (effect == SPELL_EFFECT_TELEPORT_UNITS);
}

inline bool IsAreaAuraEffect(uint32 effect) {
	if (effect == SPELL_EFFECT_APPLY_AREA_AURA_PARTY
			|| effect == SPELL_EFFECT_APPLY_AREA_AURA_RAID
			|| effect == SPELL_EFFECT_APPLY_AREA_AURA_FRIEND
			|| effect == SPELL_EFFECT_APPLY_AREA_AURA_ENEMY
			|| effect == SPELL_EFFECT_APPLY_AREA_AURA_PET
			|| effect == SPELL_EFFECT_APPLY_AREA_AURA_OWNER)
		return true;
	return false;
}

inline bool HasAreaAuraEffect(SpellEntry const *spellInfo) {
	for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
		if (IsAreaAuraEffect(spellInfo->Effect[i]))
			return true;
	return false;
}

inline bool IsUnitOwnedAuraEffect(uint32 effect) {
	return (IsAreaAuraEffect(effect) || effect == SPELL_EFFECT_APPLY_AURA);
}

inline bool IsDispel(SpellEntry const *spellInfo) {
	//spellsteal is also dispel
	if (spellInfo->Effect[0] == SPELL_EFFECT_DISPEL
			|| spellInfo->Effect[1] == SPELL_EFFECT_DISPEL
			|| spellInfo->Effect[2] == SPELL_EFFECT_DISPEL)
		return true;
	return false;
}

inline bool IsDispelSpell(SpellEntry const *spellInfo) {
	//spellsteal is also dispel
	if (spellInfo->Effect[0] == SPELL_EFFECT_STEAL_BENEFICIAL_BUFF
			|| spellInfo->Effect[1] == SPELL_EFFECT_STEAL_BENEFICIAL_BUFF
			|| spellInfo->Effect[2] == SPELL_EFFECT_STEAL_BENEFICIAL_BUFF
			|| IsDispel(spellInfo))
		return true;
	return false;
}

inline bool isSpellBreakStealth(SpellEntry const* spellInfo) {
	return !(spellInfo->AttributesEx & SPELL_ATTR1_NOT_BREAK_STEALTH);
}

inline bool IsAutoRepeatRangedSpell(SpellEntry const* spellInfo) {
	return spellInfo->AttributesEx2 & SPELL_ATTR2_AUTOREPEAT_FLAG;
}

inline bool IsRangedWeaponSpell(SpellEntry const* spellInfo) {
	//spell->DmgClass == SPELL_DAMAGE_CLASS_RANGED should be checked outside
	return (spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER
			&& !(spellInfo->SpellFamilyFlags[1] & 0x10000000)) // for 53352, cannot find better way
	|| (spellInfo->EquippedItemSubClassMask & ITEM_SUBCLASS_MASK_WEAPON_RANGED);
}

SpellCastResult GetErrorAtShapeshiftedCast(SpellEntry const *spellInfo,
		uint32 form);

inline bool IsChanneledSpell(SpellEntry const* spellInfo) {
	return (spellInfo->AttributesEx
			& (SPELL_ATTR1_CHANNELED_1 | SPELL_ATTR1_CHANNELED_2));
}

inline bool NeedsComboPoints(SpellEntry const* spellInfo) {
	return (spellInfo->AttributesEx
			& (SPELL_ATTR1_REQ_COMBO_POINTS1 | SPELL_ATTR1_REQ_COMBO_POINTS2));
}

inline SpellSchoolMask GetSpellSchoolMask(SpellEntry const* spellInfo) {
	return SpellSchoolMask(spellInfo->SchoolMask);
}

inline uint32 GetSpellMechanicMask(SpellEntry const* spellInfo, int32 effect) {
	uint32 mask = 0;
	if (spellInfo->Mechanic)
		mask |= 1 << spellInfo->Mechanic;
	if (spellInfo->EffectMechanic[effect])
		mask |= 1 << spellInfo->EffectMechanic[effect];
	return mask;
}

inline uint32 GetAllSpellMechanicMask(SpellEntry const* spellInfo) {
	uint32 mask = 0;
	if (spellInfo->Mechanic)
		mask |= 1 << spellInfo->Mechanic;
	for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
		if (spellInfo->Effect[i] && spellInfo->EffectMechanic[i])
			mask |= 1 << spellInfo->EffectMechanic[i];
	return mask;
}

inline Mechanics GetEffectMechanic(SpellEntry const* spellInfo, int32 effect) {
	if (spellInfo->EffectMechanic[effect])
		return Mechanics(spellInfo->EffectMechanic[effect]);
	if (spellInfo->Mechanic)
		return Mechanics(spellInfo->Mechanic);
	return MECHANIC_NONE;
}

inline uint32 GetDispellMask(DispelType dispel) {
	// If dispel all
	if (dispel == DISPEL_ALL)
		return DISPEL_ALL_MASK;
	else
		return (1 << dispel);
}

// Diminishing Returns interaction with spells
DiminishingGroup GetDiminishingReturnsGroupForSpell(
		SpellEntry const* spellproto, bool triggered);
bool IsDiminishingReturnsGroupDurationLimited(DiminishingGroup group);
DiminishingReturnsType GetDiminishingReturnsGroupType(DiminishingGroup group);
DiminishingLevels GetDiminishingReturnsMaxLevel(DiminishingGroup group);
int32 GetDiminishingReturnsLimitDuration(DiminishingGroup group,
		SpellEntry const* spellproto);

// Spell proc event related declarations (accessed using SpellMgr functions)
enum ProcFlags {
	PROC_FLAG_NONE = 0x00000000,

	PROC_FLAG_KILLED = 0x00000001, // 00 Killed by agressor - not sure about this flag
	PROC_FLAG_KILL = 0x00000002, // 01 Kill target (in most cases need XP/Honor reward)

	PROC_FLAG_DONE_MELEE_AUTO_ATTACK = 0x00000004, // 02 Done melee auto attack
	PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK = 0x00000008, // 03 Taken melee auto attack

	PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS = 0x00000010, // 04 Done attack by Spell that has dmg class melee
	PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS = 0x00000020, // 05 Taken attack by Spell that has dmg class melee

	PROC_FLAG_DONE_RANGED_AUTO_ATTACK = 0x00000040, // 06 Done ranged auto attack
	PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK = 0x00000080, // 07 Taken ranged auto attack

	PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS = 0x00000100, // 08 Done attack by Spell that has dmg class ranged
	PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS = 0x00000200, // 09 Taken attack by Spell that has dmg class ranged

	PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS = 0x00000400, // 10 Done positive spell that has dmg class none
	PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS = 0x00000800, // 11 Taken positive spell that has dmg class none

	PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG = 0x00001000, // 12 Done negative spell that has dmg class none
	PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG = 0x00002000, // 13 Taken negative spell that has dmg class none

	PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS = 0x00004000, // 14 Done positive spell that has dmg class magic
	PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS = 0x00008000, // 15 Taken positive spell that has dmg class magic

	PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG = 0x00010000, // 16 Done negative spell that has dmg class magic
	PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG = 0x00020000, // 17 Taken negative spell that has dmg class magic

	PROC_FLAG_DONE_PERIODIC = 0x00040000, // 18 Successful do periodic (damage / healing)
	PROC_FLAG_TAKEN_PERIODIC = 0x00080000, // 19 Taken spell periodic (damage / healing)

	PROC_FLAG_TAKEN_DAMAGE = 0x00100000, // 20 Taken any damage
	PROC_FLAG_DONE_TRAP_ACTIVATION = 0x00200000, // 21 On trap activation (possibly needs name change to ON_GAMEOBJECT_CAST or USE)

	PROC_FLAG_DONE_MAINHAND_ATTACK = 0x00400000, // 22 Done main-hand melee attacks (spell and autoattack)
	PROC_FLAG_DONE_OFFHAND_ATTACK = 0x00800000, // 23 Done off-hand melee attacks (spell and autoattack)

	PROC_FLAG_DEATH = 0x01000000
// 24 Died in any way
};

#define MELEE_BASED_TRIGGER_MASK (PROC_FLAG_DONE_MELEE_AUTO_ATTACK      | \
                                  PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK     | \
                                  PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS  | \
                                  PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS | \
                                  PROC_FLAG_DONE_RANGED_AUTO_ATTACK     | \
                                  PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK    | \
                                  PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS | \
                                  PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS)

enum ProcFlagsEx {
	PROC_EX_NONE = 0x0000000, // If none can tigger on Hit/Crit only (passive spells MUST defined by SpellFamily flag)
	PROC_EX_NORMAL_HIT = 0x0000001, // If set only from normal hit (only damage spells)
	PROC_EX_CRITICAL_HIT = 0x0000002,
	PROC_EX_MISS = 0x0000004,
	PROC_EX_RESIST = 0x0000008,
	PROC_EX_DODGE = 0x0000010,
	PROC_EX_PARRY = 0x0000020,
	PROC_EX_BLOCK = 0x0000040,
	PROC_EX_EVADE = 0x0000080,
	PROC_EX_IMMUNE = 0x0000100,
	PROC_EX_DEFLECT = 0x0000200,
	PROC_EX_ABSORB = 0x0000400,
	PROC_EX_REFLECT = 0x0000800,
	PROC_EX_INTERRUPT = 0x0001000, // Melee hit result can be Interrupt (not used)
	PROC_EX_FULL_BLOCK = 0x0002000, // block al attack damage
	PROC_EX_RESERVED2 = 0x0004000,
	PROC_EX_NOT_ACTIVE_SPELL = 0x0008000, // Spell mustn't do damage/heal to proc
	PROC_EX_EX_TRIGGER_ALWAYS = 0x0010000, // If set trigger always no matter of hit result
	PROC_EX_EX_ONE_TIME_TRIGGER = 0x0020000, // If set trigger always but only one time (not implemented yet)
	PROC_EX_ONLY_ACTIVE_SPELL = 0x0040000, // Spell has to do damage/heal to proc

	// Flags for internal use - do not use these in db!
	PROC_EX_INTERNAL_CANT_PROC = 0x0800000,
	PROC_EX_INTERNAL_DOT = 0x1000000,
	PROC_EX_INTERNAL_HOT = 0x2000000,
	PROC_EX_INTERNAL_TRIGGERED = 0x4000000,
	PROC_EX_INTERNAL_REQ_FAMILY = 0x8000000
};

#define AURA_SPELL_PROC_EX_MASK \
   (PROC_EX_NORMAL_HIT | PROC_EX_CRITICAL_HIT | PROC_EX_MISS | \
    PROC_EX_RESIST | PROC_EX_DODGE | PROC_EX_PARRY | PROC_EX_BLOCK | \
    PROC_EX_EVADE | PROC_EX_IMMUNE | PROC_EX_DEFLECT | \
    PROC_EX_ABSORB | PROC_EX_REFLECT | PROC_EX_INTERRUPT)

struct SpellProcEventEntry {
	uint32 schoolMask; // if nonzero - bit mask for matching proc condition based on spell candidate's school: Fire=2, Mask=1<<(2-1)=2
	uint32 spellFamilyName; // if nonzero - for matching proc condition based on candidate spell's SpellFamilyNamer value
	flag96 spellFamilyMask; // if nonzero - for matching proc condition based on candidate spell's SpellFamilyFlags  (like auras 107 and 108 do)
	uint32 procFlags; // bitmask for matching proc event
	uint32 procEx; // proc Extend info (see ProcFlagsEx)
	float ppmRate; // for melee (ranged?) damage spells - proc rate per minute. if zero, falls back to flat chance from Spell.dbc
	float customChance; // Owerride chance (in most cases for debug only)
	uint32 cooldown; // hidden cooldown used for some spell proc events, applied to _triggered_spell_
};

struct SpellBonusEntry {
	float direct_damage;
	float dot_damage;
	float ap_bonus;
	float ap_dot_bonus;
};

typedef UNORDERED_MAP<uint32, SpellProcEventEntry> SpellProcEventMap;

struct SpellEnchantProcEntry {
	uint32 customChance;
	float PPMChance;
	uint32 procEx;
};

typedef UNORDERED_MAP<uint32, SpellEnchantProcEntry> SpellEnchantProcEventMap;
typedef UNORDERED_MAP<uint32, SpellBonusEntry> SpellBonusMap;

enum SpellGroup {
	SPELL_GROUP_ELIXIR_BATTLE = 1,
	SPELL_GROUP_ELIXIR_GUARDIAN = 2,
	SPELL_GROUP_ELIXIR_UNSTABLE = 3,
	SPELL_GROUP_ELIXIR_SHATTRATH = 4,
	SPELL_GROUP_CORE_RANGE_MAX = 5,
};

#define SPELL_GROUP_DB_RANGE_MIN 1000

//                  spell_id, group_id
typedef std::multimap<uint32, SpellGroup> SpellSpellGroupMap;
typedef std::pair<SpellSpellGroupMap::const_iterator,
		SpellSpellGroupMap::const_iterator> SpellSpellGroupMapBounds;

//                      group_id, spell_id
typedef std::multimap<SpellGroup, int32> SpellGroupSpellMap;
typedef std::pair<SpellGroupSpellMap::const_iterator,
		SpellGroupSpellMap::const_iterator> SpellGroupSpellMapBounds;

enum SpellGroupStackRule {
	SPELL_GROUP_STACK_RULE_DEFAULT = 0,
	SPELL_GROUP_STACK_RULE_EXCLUSIVE = 1,
	SPELL_GROUP_STACK_RULE_EXCLUSIVE_FROM_SAME_CASTER = 2,
};
#define SPELL_GROUP_STACK_RULE_MAX 3

typedef std::map<SpellGroup, SpellGroupStackRule> SpellGroupStackMap;

typedef std::map<uint32, uint16> SpellThreatMap;

// Spell script target related declarations (accessed using SpellMgr functions)
enum SpellScriptTargetType {
	SPELL_TARGET_TYPE_GAMEOBJECT = 0,
	SPELL_TARGET_TYPE_CREATURE = 1,
	SPELL_TARGET_TYPE_DEAD = 2,
	SPELL_TARGET_TYPE_CONTROLLED = 3,
};

#define MAX_SPELL_TARGET_TYPE 4

struct SpellTargetEntry {
	SpellTargetEntry(SpellScriptTargetType type_, uint32 targetEntry_) :
			type(type_), targetEntry(targetEntry_) {
	}
	SpellScriptTargetType type;
	uint32 targetEntry;
};

// coordinates for spells (accessed using SpellMgr functions)
struct SpellTargetPosition {
	uint32 target_mapId;
	float target_X;
	float target_Y;
	float target_Z;
	float target_Orientation;
};

typedef UNORDERED_MAP<uint32, SpellTargetPosition> SpellTargetPositionMap;

// Spell pet auras
class PetAura {
public:
	PetAura() {
		auras.clear();
	}

	PetAura(uint32 petEntry, uint32 aura, bool _removeOnChangePet, int _damage) :
			removeOnChangePet(_removeOnChangePet), damage(_damage) {
		auras[petEntry] = aura;
	}

	uint32 GetAura(uint32 petEntry) const {
		std::map<uint32, uint32>::const_iterator itr = auras.find(petEntry);
		if (itr != auras.end())
			return itr->second;
		std::map<uint32, uint32>::const_iterator itr2 = auras.find(0);
		if (itr2 != auras.end())
			return itr2->second;
		return 0;
	}

	void AddAura(uint32 petEntry, uint32 aura) {
		auras[petEntry] = aura;
	}

	bool IsRemovedOnChangePet() const {
		return removeOnChangePet;
	}

	int32 GetDamage() const {
		return damage;
	}

private:
	std::map<uint32, uint32> auras;
	bool removeOnChangePet;
	int32 damage;
};
typedef std::map<uint32, PetAura> SpellPetAuraMap;

struct SpellArea {
	uint32 spellId;
	uint32 areaId; // zone/subzone/or 0 is not limited to zone
	uint32 questStart; // quest start (quest must be active or rewarded for spell apply)
	uint32 questEnd; // quest end (quest don't must be rewarded for spell apply)
	int32 auraSpell; // spell aura must be applied for spell apply)if possitive) and it don't must be applied in other case
	uint32 raceMask; // can be applied only to races
	Gender gender; // can be applied only to gender
	bool questStartCanActive; // if true then quest start can be active (not only rewarded)
	bool autocast; // if true then auto applied at area enter, in other case just allowed to cast

	// helpers
	bool IsFitToRequirements(Player const* player, uint32 newZone,
			uint32 newArea) const;
};

typedef std::multimap<uint32, SpellArea> SpellAreaMap;
typedef std::multimap<uint32, SpellArea const*> SpellAreaForQuestMap;
typedef std::multimap<uint32, SpellArea const*> SpellAreaForAuraMap;
typedef std::multimap<uint32, SpellArea const*> SpellAreaForAreaMap;
typedef std::pair<SpellAreaMap::const_iterator, SpellAreaMap::const_iterator> SpellAreaMapBounds;
typedef std::pair<SpellAreaForQuestMap::const_iterator,
		SpellAreaForQuestMap::const_iterator> SpellAreaForQuestMapBounds;
typedef std::pair<SpellAreaForAuraMap::const_iterator,
		SpellAreaForAuraMap::const_iterator> SpellAreaForAuraMapBounds;
typedef std::pair<SpellAreaForAreaMap::const_iterator,
		SpellAreaForAreaMap::const_iterator> SpellAreaForAreaMapBounds;

// Spell rank chain  (accessed using SpellMgr functions)
struct SpellChainNode {
	uint32 prev;
	uint32 next;
	uint32 first;
	uint32 last;
	uint8 rank;
};

typedef UNORDERED_MAP<uint32, SpellChainNode> SpellChainMap;

//                   spell_id  req_spell
typedef std::multimap<uint32, uint32> SpellRequiredMap;
typedef std::pair<SpellRequiredMap::const_iterator,
		SpellRequiredMap::const_iterator> SpellRequiredMapBounds;

//                   req_spell spell_id
typedef std::multimap<uint32, uint32> SpellsRequiringSpellMap;
typedef std::pair<SpellsRequiringSpellMap::const_iterator,
		SpellsRequiringSpellMap::const_iterator> SpellsRequiringSpellMapBounds;

// Spell learning properties (accessed using SpellMgr functions)
struct SpellLearnSkillNode {
	uint16 skill;
	uint16 step;
	uint16 value; // 0  - max skill value for player level
	uint16 maxvalue; // 0  - max skill value for player level
};

typedef std::map<uint32, SpellLearnSkillNode> SpellLearnSkillMap;

struct SpellLearnSpellNode {
	uint32 spell;
	bool active; // show in spellbook or not
	bool autoLearned;
};

typedef std::multimap<uint32, SpellLearnSpellNode> SpellLearnSpellMap;
typedef std::pair<SpellLearnSpellMap::const_iterator,
		SpellLearnSpellMap::const_iterator> SpellLearnSpellMapBounds;

typedef std::multimap<uint32, SkillLineAbilityEntry const*> SkillLineAbilityMap;
typedef std::pair<SkillLineAbilityMap::const_iterator,
		SkillLineAbilityMap::const_iterator> SkillLineAbilityMapBounds;

typedef std::multimap<uint32, uint32> PetLevelupSpellSet;
typedef std::map<uint32, PetLevelupSpellSet> PetLevelupSpellMap;

typedef std::map<uint32, uint32> SpellDifficultySearcherMap;

struct PetDefaultSpellsEntry {
	uint32 spellid[MAX_CREATURE_SPELL_DATA_SLOT];
};

// < 0 for petspelldata id, > 0 for creature_id
typedef std::map<int32, PetDefaultSpellsEntry> PetDefaultSpellsMap;

inline bool IsPrimaryProfessionSkill(uint32 skill) {
	SkillLineEntry const *pSkill = sSkillLineStore.LookupEntry(skill);
	if (!pSkill)
		return false;

	if (pSkill->categoryId != SKILL_CATEGORY_PROFESSION)
		return false;

	return true;
}

inline bool IsProfessionSkill(uint32 skill) {
	return IsPrimaryProfessionSkill(skill) || skill == SKILL_FISHING
			|| skill == SKILL_COOKING || skill == SKILL_FIRST_AID
			|| skill == SKILL_ARCHAEOLOGY;
}

enum SpellCustomAttributes {
	SPELL_ATTR0_CU_ENCHANT_PROC = 0x00000001,
	SPELL_ATTR0_CU_CONE_BACK = 0x00000002,
	SPELL_ATTR0_CU_CONE_LINE = 0x00000004,
	SPELL_ATTR0_CU_SHARE_DAMAGE = 0x00000008,
	SPELL_ATTR0_CU_NONE1 = 0x00000010, // UNUSED
	SPELL_ATTR0_CU_NONE2 = 0x00000020, // UNUSED
	SPELL_ATTR0_CU_AURA_CC = 0x00000040,
	SPELL_ATTR0_CU_DIRECT_DAMAGE = 0x00000100,
	SPELL_ATTR0_CU_CHARGE = 0x00000200,
	SPELL_ATTR0_CU_LINK_CAST = 0x00000400,
	SPELL_ATTR0_CU_LINK_HIT = 0x00000800,
	SPELL_ATTR0_CU_LINK_AURA = 0x00001000,
	SPELL_ATTR0_CU_LINK_REMOVE = 0x00002000,
	SPELL_ATTR0_CU_PICKPOCKET = 0x00004000,
	SPELL_ATTR0_CU_EXCLUDE_SELF = 0x00008000,
	SPELL_ATTR0_CU_NEGATIVE_EFF0 = 0x00010000,
	SPELL_ATTR0_CU_NEGATIVE_EFF1 = 0x00020000,
	SPELL_ATTR0_CU_NEGATIVE_EFF2 = 0x00040000,
	SPELL_ATTR0_CU_IGNORE_ARMOR = 0x00080000,

	SPELL_ATTR0_CU_NEGATIVE = SPELL_ATTR0_CU_NEGATIVE_EFF0
			| SPELL_ATTR0_CU_NEGATIVE_EFF1 | SPELL_ATTR0_CU_NEGATIVE_EFF2,
};

typedef std::vector<uint32> SpellCustomAttribute;
typedef std::vector<bool> EnchantCustomAttribute;

typedef std::map<int32, std::vector<int32> > SpellLinkedMap;

inline bool IsProfessionOrRidingSkill(uint32 skill) {
	return IsProfessionSkill(skill) || skill == SKILL_RIDING;
}

inline float roundf(float value) {
	return floor(value + 0.5f);
}

struct SpellScaling {
	uint8 playerLevel;
	const SpellEntry * spellEntry;

	float avg[3];
	float min[3];
	float max[3];
	float pts[3];

	int32 cast;

	bool canScale;
	SpellScaling(uint8 playerLevel_, const SpellEntry * spellEntry_);
};

bool IsPartOfSkillLine(uint32 skillId, uint32 spellId);

class SpellMgr {
	friend class ACE_Singleton<SpellMgr, ACE_Null_Mutex> ;
	SpellMgr();
	~SpellMgr();

	// Accessors (const or static functions)
public:

	bool IsAffectedByMod(SpellEntry const *spellInfo, SpellModifier *mod) const;

	SpellSpellGroupMapBounds GetSpellSpellGroupMapBounds(
			uint32 spell_id) const {
		spell_id = GetFirstSpellInChain(spell_id);
		return SpellSpellGroupMapBounds(mSpellSpellGroup.lower_bound(spell_id),
				mSpellSpellGroup.upper_bound(spell_id));
	}
	uint32 IsSpellMemberOfSpellGroup(uint32 spellid, SpellGroup groupid) const {
		SpellSpellGroupMapBounds spellGroup = GetSpellSpellGroupMapBounds(
				spellid);
		for (SpellSpellGroupMap::const_iterator itr = spellGroup.first;
				itr != spellGroup.second; ++itr) {
			if (itr->second == groupid)
				return true;
		}
		return false;
	}

	SpellGroupSpellMapBounds GetSpellGroupSpellMapBounds(
			SpellGroup group_id) const {
		return SpellGroupSpellMapBounds(mSpellGroupSpell.lower_bound(group_id),
				mSpellGroupSpell.upper_bound(group_id));
	}
	void GetSetOfSpellsInSpellGroup(SpellGroup group_id,
			std::set<uint32>& foundSpells) const {
		std::set<SpellGroup> usedGroups;
		GetSetOfSpellsInSpellGroup(group_id, foundSpells, usedGroups);
	}
	void GetSetOfSpellsInSpellGroup(SpellGroup group_id,
			std::set<uint32>& foundSpells,
			std::set<SpellGroup>& usedGroups) const {
		if (usedGroups.find(group_id) != usedGroups.end())
			return;
		usedGroups.insert(group_id);

		SpellGroupSpellMapBounds groupSpell = GetSpellGroupSpellMapBounds(
				group_id);
		for (SpellGroupSpellMap::const_iterator itr = groupSpell.first;
				itr != groupSpell.second; ++itr) {
			if (itr->second < 0) {
				SpellGroup currGroup = (SpellGroup) abs(itr->second);
				GetSetOfSpellsInSpellGroup(currGroup, foundSpells, usedGroups);
			} else {
				foundSpells.insert(itr->second);
			}
		}
	}

	SpellGroupStackRule CheckSpellGroupStackRules(uint32 spellid_1,
			uint32 spellid_2) const {
		spellid_1 = GetFirstSpellInChain(spellid_1);
		spellid_2 = GetFirstSpellInChain(spellid_2);
		if (spellid_1 == spellid_2)
			return SPELL_GROUP_STACK_RULE_DEFAULT;
		// find SpellGroups which are common for both spells
		SpellSpellGroupMapBounds spellGroup1 = GetSpellSpellGroupMapBounds(
				spellid_1);
		std::set<SpellGroup> groups;
		for (SpellSpellGroupMap::const_iterator itr = spellGroup1.first;
				itr != spellGroup1.second; ++itr) {
			if (IsSpellMemberOfSpellGroup(spellid_2, itr->second)) {
				bool add = true;
				SpellGroupSpellMapBounds groupSpell =
						GetSpellGroupSpellMapBounds(itr->second);
				for (SpellGroupSpellMap::const_iterator itr2 = groupSpell.first;
						itr2 != groupSpell.second; ++itr2) {
					if (itr2->second < 0) {
						SpellGroup currGroup = (SpellGroup) abs(itr2->second);
						if (IsSpellMemberOfSpellGroup(spellid_1, currGroup)
								&& IsSpellMemberOfSpellGroup(spellid_2,
										currGroup)) {
							add = false;
							break;
						}
					}
				}
				if (add)
					groups.insert(itr->second);
			}
		}

		SpellGroupStackRule rule = SPELL_GROUP_STACK_RULE_DEFAULT;

		for (std::set<SpellGroup>::iterator itr = groups.begin();
				itr != groups.end(); ++itr) {
			SpellGroupStackMap::const_iterator found = mSpellGroupStack.find(
					*itr);
			if (found != mSpellGroupStack.end())
				rule = found->second;
			if (rule)
				break;
		}
		return rule;
	}

	uint16 GetSpellThreat(uint32 spellid) const {
		SpellThreatMap::const_iterator itr = mSpellThreatMap.find(spellid);
		if (itr == mSpellThreatMap.end())
			return 0;

		return itr->second;
	}

	// Spell proc events
	SpellProcEventEntry const* GetSpellProcEvent(uint32 spellId) const {
		SpellProcEventMap::const_iterator itr = mSpellProcEventMap.find(
				spellId);
		if (itr != mSpellProcEventMap.end())
			return &itr->second;
		return NULL;
	}

	bool IsSpellProcEventCanTriggeredBy(
			SpellProcEventEntry const * spellProcEvent, uint32 EventProcFlag,
			SpellEntry const * procSpell, uint32 procFlags, uint32 procExtra,
			bool active);

	SpellEnchantProcEntry const* GetSpellEnchantProcEvent(uint32 enchId) const {
		SpellEnchantProcEventMap::const_iterator itr =
				mSpellEnchantProcEventMap.find(enchId);
		if (itr != mSpellEnchantProcEventMap.end())
			return &itr->second;
		return NULL;
	}

	// Spell bonus data
	SpellBonusEntry const* GetSpellBonusData(uint32 spellId) const {
		// Lookup data
		SpellBonusMap::const_iterator itr = mSpellBonusMap.find(spellId);
		if (itr != mSpellBonusMap.end())
			return &itr->second;
		// Not found, try lookup for 1 spell rank if exist
		if (uint32 rank_1 = GetFirstSpellInChain(spellId)) {
			SpellBonusMap::const_iterator itr2 = mSpellBonusMap.find(rank_1);
			if (itr2 != mSpellBonusMap.end())
				return &itr2->second;
		}
		return NULL;
	}

	// Spell Difficulty data
	SpellEntry const* GetSpellForDifficultyFromSpell(SpellEntry const* spell,
			Unit* Caster) {
		//spell never can be NULL in this case!
		if (!Caster || !Caster->GetMap() || !Caster->GetMap()->IsDungeon())
			return spell;

		uint32 mode = uint32(Caster->GetMap()->GetSpawnMode());
		if (mode >= MAX_DIFFICULTY) {
			sLog->outError(
					"GetSpellForDifficultyFromSpell: Incorrect Difficulty for spell %u.",
					spell->Id);
			return spell; //return source spell
		}
		uint32 SpellDiffId = GetSpellDifficultyId(spell->Id);
		if (!SpellDiffId)
			return spell; //return source spell, it has only REGULAR_DIFFICULTY

		SpellDifficultyEntry const *SpellDiff =
				sSpellDifficultyStore.LookupEntry(SpellDiffId);
		if (!SpellDiff) {
			sLog->outDebug(
					LOG_FILTER_SPELLS_AURAS,
					"GetSpellForDifficultyFromSpell: SpellDifficultyEntry not found for spell %u. This Should never happen.",
					spell->Id);
			return spell; //return source spell
		}
		if (SpellDiff->SpellID[mode] <= 0 && mode > DUNGEON_DIFFICULTY_HEROIC) {
			uint8 baseMode = mode;
			mode -= 2;
			sLog->outDebug(
					LOG_FILTER_SPELLS_AURAS,
					"GetSpellForDifficultyFromSpell: spell %u mode %u spell is NULL, using mode %u",
					spell->Id, baseMode, mode);
		}
		if (SpellDiff->SpellID[mode] <= 0) {
			sLog->outErrorDb(
					"GetSpellForDifficultyFromSpell: spell %u mode %u spell is 0. Check spelldifficulty_dbc!",
					spell->Id, mode);
			return spell;
		}
		SpellEntry const* newSpell = sSpellStore.LookupEntry(
				SpellDiff->SpellID[mode]);
		if (!newSpell) {
			sLog->outDebug(
					LOG_FILTER_SPELLS_AURAS,
					"GetSpellForDifficultyFromSpell: spell %u not found in SpellStore. Check spelldifficulty_dbc!",
					SpellDiff->SpellID[mode]);
			return spell;
		}
		sLog->outDebug(
				LOG_FILTER_SPELLS_AURAS,
				"GetSpellForDifficultyFromSpell: spellid for spell %u in mode %u is %u ",
				spell->Id, mode, newSpell->Id);
		return newSpell;
	}

	// Spell target coordinates
	SpellTargetPosition const* GetSpellTargetPosition(uint32 spell_id) const {
		SpellTargetPositionMap::const_iterator itr = mSpellTargetPositions.find(
				spell_id);
		if (itr != mSpellTargetPositions.end())
			return &itr->second;
		return NULL;
	}

	// Spell ranks chains
	SpellChainNode const* GetSpellChainNode(uint32 spell_id) const {
		SpellChainMap::const_iterator itr = mSpellChains.find(spell_id);
		if (itr == mSpellChains.end())
			return NULL;

		return &itr->second;
	}

	uint32 GetFirstSpellInChain(uint32 spell_id) const {
		if (SpellChainNode const* node = GetSpellChainNode(spell_id))
			return node->first;

		return spell_id;
	}

	// not strict check returns provided spell if rank not avalible
	uint32 GetSpellWithRank(uint32 spell_id, uint32 rank,
			bool strict = false) const {
		if (SpellChainNode const* node = GetSpellChainNode(spell_id)) {
			if (rank != node->rank)
				return GetSpellWithRank(
						node->rank < rank ? node->next : node->prev, rank,
						strict);
		} else if (strict && rank > 1)
			return 0;
		return spell_id;
	}

	uint32 GetPrevSpellInChain(uint32 spell_id) const {
		if (SpellChainNode const* node = GetSpellChainNode(spell_id))
			return node->prev;

		return 0;
	}

	uint32 GetNextSpellInChain(uint32 spell_id) const {
		if (SpellChainNode const* node = GetSpellChainNode(spell_id))
			return node->next;

		return 0;
	}

	SpellRequiredMapBounds GetSpellsRequiredForSpellBounds(
			uint32 spell_id) const {
		return SpellRequiredMapBounds(mSpellReq.lower_bound(spell_id),
				mSpellReq.upper_bound(spell_id));
	}

	SpellsRequiringSpellMapBounds GetSpellsRequiringSpellBounds(
			uint32 spell_id) const {
		return SpellsRequiringSpellMapBounds(
				mSpellsReqSpell.lower_bound(spell_id),
				mSpellsReqSpell.upper_bound(spell_id));
	}
	bool IsSpellRequiringSpell(uint32 spellid, uint32 req_spellid) const {
		SpellsRequiringSpellMapBounds spellsRequiringSpell =
				GetSpellsRequiringSpellBounds(req_spellid);
		for (SpellsRequiringSpellMap::const_iterator itr =
				spellsRequiringSpell.first; itr != spellsRequiringSpell.second;
				++itr) {
			if (itr->second == spellid)
				return true;
		}
		return false;
	}

	uint8 GetSpellRank(uint32 spell_id) const {
		if (SpellChainNode const* node = GetSpellChainNode(spell_id))
			return node->rank;

		return 0;
	}

	uint32 GetLastSpellInChain(uint32 spell_id) const {
		if (SpellChainNode const* node = GetSpellChainNode(spell_id))
			return node->last;

		return spell_id;
	}

	uint32 IsArenaAllowedEnchancment(uint32 ench_id) const {
		return mEnchantCustomAttr[ench_id];
	}

	uint8 IsHighRankOfSpell(uint32 spell1, uint32 spell2) const {
		SpellChainMap::const_iterator itr1 = mSpellChains.find(spell1);
		SpellChainMap::const_iterator itr2 = mSpellChains.find(spell2);
		if (itr1 == mSpellChains.end() || itr2 == mSpellChains.end())
			return false;

		if (itr1->second.first == itr2->second.first)
			if (itr1->second.rank > itr2->second.rank)
				return true;
		return false;
	}

	bool IsRankSpellDueToSpell(SpellEntry const *spellInfo_1,
			uint32 spellId_2) const;
	static bool canStackSpellRanks(SpellEntry const *spellInfo);
	bool CanAurasStack(Aura const *aura1, Aura const *aura2,
			bool sameCaster) const;

	SpellEntry const* SelectAuraRankForPlayerLevel(SpellEntry const* spellInfo,
			uint32 playerLevel) const;

	// Spell learning
	SpellLearnSkillNode const* GetSpellLearnSkill(uint32 spell_id) const {
		SpellLearnSkillMap::const_iterator itr = mSpellLearnSkills.find(
				spell_id);
		if (itr != mSpellLearnSkills.end())
			return &itr->second;
		else
			return NULL;
	}

	bool IsSpellLearnSpell(uint32 spell_id) const {
		return mSpellLearnSpells.find(spell_id) != mSpellLearnSpells.end();
	}

	SpellLearnSpellMapBounds GetSpellLearnSpellMapBounds(
			uint32 spell_id) const {
		return SpellLearnSpellMapBounds(mSpellLearnSpells.lower_bound(spell_id),
				mSpellLearnSpells.upper_bound(spell_id));
	}

	bool IsSpellLearnToSpell(uint32 spell_id1, uint32 spell_id2) const {
		SpellLearnSpellMapBounds bounds = GetSpellLearnSpellMapBounds(
				spell_id1);
		for (SpellLearnSpellMap::const_iterator i = bounds.first;
				i != bounds.second; ++i)
			if (i->second.spell == spell_id2)
				return true;
		return false;
	}

	static bool IsProfessionOrRidingSpell(uint32 spellId);
	static bool IsProfessionSpell(uint32 spellId);
	static bool IsPrimaryProfessionSpell(uint32 spellId);
	bool IsPrimaryProfessionFirstRankSpell(uint32 spellId) const;

	bool IsSkillBonusSpell(uint32 spellId) const;
	bool IsSkillTypeSpell(uint32 spellId, SkillType type) const;
	static int32 CalculateSpellEffectAmount(SpellEntry const * spellEntry,
			uint8 effIndex, Unit const * caster = NULL,
			int32 const * basePoints = NULL, Unit const * target = NULL);
	static int32 CalculateSpellEffectBaseAmount(int32 value,
			SpellEntry const * spellEntry, uint8 effIndex);
	static float CalculateSpellEffectValueMultiplier(
			SpellEntry const * spellEntry, uint8 effIndex, Unit * caster,
			Spell * spell = NULL);
	static float CalculateSpellEffectDamageMultiplier(
			SpellEntry const * spellEntry, uint8 effIndex, Unit * caster,
			Spell * spell = NULL);

	// Spell correctess for client using
	static bool IsSpellValid(SpellEntry const * spellInfo, Player* pl = NULL,
			bool msg = true);

	SkillLineAbilityMapBounds GetSkillLineAbilityMapBounds(
			uint32 spell_id) const {
		return SkillLineAbilityMapBounds(
				mSkillLineAbilityMap.lower_bound(spell_id),
				mSkillLineAbilityMap.upper_bound(spell_id));
	}

	PetAura const* GetPetAura(uint32 spell_id, uint8 eff) {
		SpellPetAuraMap::const_iterator itr = mSpellPetAuraMap.find(
				(spell_id << 8) + eff);
		if (itr != mSpellPetAuraMap.end())
			return &itr->second;
		else
			return NULL;
	}

	PetLevelupSpellSet const* GetPetLevelupSpellList(uint32 petFamily) const {
		PetLevelupSpellMap::const_iterator itr = mPetLevelupSpellMap.find(
				petFamily);
		if (itr != mPetLevelupSpellMap.end())
			return &itr->second;
		else
			return NULL;
	}

	uint32 GetSpellCustomAttr(uint32 spell_id) const {
		if (spell_id >= mSpellCustomAttr.size())
			return 0;
		else
			return mSpellCustomAttr[spell_id];
	}

	const std::vector<int32> *GetSpellLinked(int32 spell_id) const {
		SpellLinkedMap::const_iterator itr = mSpellLinkedMap.find(spell_id);
		return itr != mSpellLinkedMap.end() ? &(itr->second) : NULL;
	}

	// < 0 for petspelldata id, > 0 for creature_id
	PetDefaultSpellsEntry const* GetPetDefaultSpellsEntry(int32 id) const {
		PetDefaultSpellsMap::const_iterator itr = mPetDefaultSpellsMap.find(id);
		if (itr != mPetDefaultSpellsMap.end())
			return &itr->second;
		return NULL;
	}

	SpellCastResult GetSpellAllowedInLocationError(SpellEntry const *spellInfo,
			uint32 map_id, uint32 zone_id, uint32 area_id,
			Player const* player = NULL);

	SpellAreaMapBounds GetSpellAreaMapBounds(uint32 spell_id) const {
		return SpellAreaMapBounds(mSpellAreaMap.lower_bound(spell_id),
				mSpellAreaMap.upper_bound(spell_id));
	}

	SpellAreaForQuestMapBounds GetSpellAreaForQuestMapBounds(uint32 quest_id,
			bool active) const {
		if (active)
			return SpellAreaForQuestMapBounds(
					mSpellAreaForActiveQuestMap.lower_bound(quest_id),
					mSpellAreaForActiveQuestMap.upper_bound(quest_id));
		else
			return SpellAreaForQuestMapBounds(
					mSpellAreaForQuestMap.lower_bound(quest_id),
					mSpellAreaForQuestMap.upper_bound(quest_id));
	}

	SpellAreaForQuestMapBounds GetSpellAreaForQuestEndMapBounds(
			uint32 quest_id) const {
		return SpellAreaForQuestMapBounds(
				mSpellAreaForQuestEndMap.lower_bound(quest_id),
				mSpellAreaForQuestEndMap.upper_bound(quest_id));
	}

	SpellAreaForAuraMapBounds GetSpellAreaForAuraMapBounds(
			uint32 spell_id) const {
		return SpellAreaForAuraMapBounds(
				mSpellAreaForAuraMap.lower_bound(spell_id),
				mSpellAreaForAuraMap.upper_bound(spell_id));
	}

	SpellAreaForAreaMapBounds GetSpellAreaForAreaMapBounds(
			uint32 area_id) const {
		return SpellAreaForAreaMapBounds(
				mSpellAreaForAreaMap.lower_bound(area_id),
				mSpellAreaForAreaMap.upper_bound(area_id));
	}

	bool IsSrcTargetSpell(SpellEntry const *spellInfo) const;

	inline bool IsCasterSourceTarget(uint32 target) {
		switch (SpellTargetType[target]) {
		case TARGET_TYPE_UNIT_TARGET:
		case TARGET_TYPE_DEST_TARGET:
			return false;
		default:
			break;
		}
		return true;
	}

	inline bool IsSpellWithCasterSourceTargetsOnly(
			SpellEntry const* spellInfo) {
		for (int i = 0; i < MAX_SPELL_EFFECTS; ++i)
			if (uint32 target = spellInfo->EffectImplicitTargetA[i])
				if (!IsCasterSourceTarget(target))
					return false;
		return true;
	}
    // Spell difficulty
	uint32 GetSpellDifficultyId(uint32 spellId) const;
    void SetSpellDifficultyId(uint32 spellId, uint32 id);
	uint32 GetSpellIdForDifficulty(uint32 spellId, Unit const* caster) const;
	const SpellsRequiringSpellMap GetSpellsRequiringSpell() {
		return this->mSpellsReqSpell;
	}

	uint32 GetSpellRequired(uint32 spell_id) const {
		SpellRequiredMap::const_iterator itr = mSpellReq.find(spell_id);

		if (itr == mSpellReq.end())
			return NULL;

		return itr->second;
	}

	// Modifiers
public:

	// Loading data at server startup
	void LoadSpellRanks();
	void LoadSpellRequired();
	void LoadSpellLearnSkills();
	void LoadSpellLearnSpells();
	void LoadSpellGroups();
	void LoadSpellProcEvents();
	void LoadSpellBonusess();
	void LoadSpellTargetPositions();
	void LoadSpellThreats();
	void LoadSkillLineAbilityMap();
	void LoadSpellPetAuras();
	void LoadSpellCustomAttr();
	void LoadEnchantCustomAttr();
	void LoadSpellEnchantProcData();
	void LoadSpellLinked();
	void LoadPetLevelupSpellMap();
	void LoadPetDefaultSpells();
	void LoadSpellAreas();
	void LoadSpellGroupStackRules();

private:
	bool _isPositiveSpell(uint32 spellId, bool deep) const;
	bool _isPositiveEffect(uint32 spellId, uint32 effIndex, bool deep) const;

	SpellChainMap mSpellChains;
	SpellsRequiringSpellMap mSpellsReqSpell;
	SpellRequiredMap mSpellReq;
	SpellLearnSkillMap mSpellLearnSkills;
	SpellLearnSpellMap mSpellLearnSpells;
	SpellTargetPositionMap mSpellTargetPositions;
	SpellSpellGroupMap mSpellSpellGroup;
	SpellGroupSpellMap mSpellGroupSpell;
	SpellThreatMap mSpellThreatMap;
	SpellProcEventMap mSpellProcEventMap;
	SpellBonusMap mSpellBonusMap;
	SkillLineAbilityMap mSkillLineAbilityMap;
	SpellPetAuraMap mSpellPetAuraMap;
	SpellCustomAttribute mSpellCustomAttr;
	SpellLinkedMap mSpellLinkedMap;
	SpellGroupStackMap mSpellGroupStack;
	SpellEnchantProcEventMap mSpellEnchantProcEventMap;
	EnchantCustomAttribute mEnchantCustomAttr;
	PetLevelupSpellMap mPetLevelupSpellMap;
	PetDefaultSpellsMap mPetDefaultSpellsMap; // only spells not listed in related mPetLevelupSpellMap entry
	SpellAreaMap mSpellAreaMap;
	SpellAreaForQuestMap mSpellAreaForQuestMap;
	SpellAreaForQuestMap mSpellAreaForActiveQuestMap;
	SpellAreaForQuestMap mSpellAreaForQuestEndMap;
	SpellAreaForAuraMap mSpellAreaForAuraMap;
	SpellAreaForAreaMap mSpellAreaForAreaMap;
	SpellDifficultySearcherMap mSpellDifficultySearcherMap;
};

#define sSpellMgr ACE_Singleton<SpellMgr, ACE_Null_Mutex>::instance()
#endif
